/*
* MATLAB Compiler: 4.18.1 (R2013a)
* Date: Fri May 24 04:57:45 2013
* Arguments: "-B" "macro_default" "-W" "dotnet:Ploter,Ploter,0.0,private" "-T" "link:lib"
* "-d" "C:\Users\leniwin\Documents\MATLAB\NET\Ploter\src" "-w"
* "enable:specified_file_mismatch" "-w" "enable:repeated_file" "-w"
* "enable:switch_ignored" "-w" "enable:missing_lib_sentinel" "-w" "enable:demo_license"
* "-v"
* "class{Ploter:C:\Users\leniwin\Documents\MATLAB\AxesDim.m,C:\Users\leniwin\Documents\MAT
* LAB\ChangeAxes.m,C:\Users\leniwin\Documents\MATLAB\ClearAxes.m,C:\Users\leniwin\Document
* s\MATLAB\CloseFigure.m,C:\Users\leniwin\Documents\MATLAB\FindStreetPosition.m,C:\Users\l
* eniwin\Documents\MATLAB\FindTLPosition.m,C:\Users\leniwin\Documents\MATLAB\HeatScale.m,C
* :\Users\leniwin\Documents\MATLAB\OpenFigure.m,C:\Users\leniwin\Documents\MATLAB\PlotCar.
* m,C:\Users\leniwin\Documents\MATLAB\PlotCircle1.m,C:\Users\leniwin\Documents\MATLAB\Plot
* Circle2.m,C:\Users\leniwin\Documents\MATLAB\PlotIteration.m,C:\Users\leniwin\Documents\M
* ATLAB\PlotLine.m,C:\Users\leniwin\Documents\MATLAB\PlotNameCircle.m,C:\Users\leniwin\Doc
* uments\MATLAB\PlotTraficLight.m}" "-a"
* "C:\Users\leniwin\Documents\MATLAB\TrafficLight.ico" 
*/
using System;
using System.Reflection;
using System.IO;
using MathWorks.MATLAB.NET.Arrays;
using MathWorks.MATLAB.NET.Utility;

#if SHARED
[assembly: System.Reflection.AssemblyKeyFile(@"")]
#endif

namespace PloterNative
{

  /// <summary>
  /// The Ploter class provides a CLS compliant, Object (native) interface to the MATLAB
  /// functions contained in the files:
  /// <newpara></newpara>
  /// C:\Users\leniwin\Documents\MATLAB\AxesDim.m
  /// <newpara></newpara>
  /// C:\Users\leniwin\Documents\MATLAB\ChangeAxes.m
  /// <newpara></newpara>
  /// C:\Users\leniwin\Documents\MATLAB\ClearAxes.m
  /// <newpara></newpara>
  /// C:\Users\leniwin\Documents\MATLAB\CloseFigure.m
  /// <newpara></newpara>
  /// C:\Users\leniwin\Documents\MATLAB\FindStreetPosition.m
  /// <newpara></newpara>
  /// C:\Users\leniwin\Documents\MATLAB\FindTLPosition.m
  /// <newpara></newpara>
  /// C:\Users\leniwin\Documents\MATLAB\HeatScale.m
  /// <newpara></newpara>
  /// C:\Users\leniwin\Documents\MATLAB\OpenFigure.m
  /// <newpara></newpara>
  /// C:\Users\leniwin\Documents\MATLAB\PlotCar.m
  /// <newpara></newpara>
  /// C:\Users\leniwin\Documents\MATLAB\PlotCircle1.m
  /// <newpara></newpara>
  /// C:\Users\leniwin\Documents\MATLAB\PlotCircle2.m
  /// <newpara></newpara>
  /// C:\Users\leniwin\Documents\MATLAB\PlotIteration.m
  /// <newpara></newpara>
  /// C:\Users\leniwin\Documents\MATLAB\PlotLine.m
  /// <newpara></newpara>
  /// C:\Users\leniwin\Documents\MATLAB\PlotNameCircle.m
  /// <newpara></newpara>
  /// C:\Users\leniwin\Documents\MATLAB\PlotTraficLight.m
  /// <newpara></newpara>
  /// deployprint.m
  /// <newpara></newpara>
  /// printdlg.m
  /// </summary>
  /// <remarks>
  /// @Version 0.0
  /// </remarks>
  public class Ploter : IDisposable
  {
    #region Constructors

    /// <summary internal= "true">
    /// The static constructor instantiates and initializes the MATLAB Compiler Runtime
    /// instance.
    /// </summary>
    static Ploter()
    {
      if (MWMCR.MCRAppInitialized)
      {
        try
        {
          Assembly assembly= Assembly.GetExecutingAssembly();

          string ctfFilePath= assembly.Location;

          int lastDelimiter= ctfFilePath.LastIndexOf(@"\");

          ctfFilePath= ctfFilePath.Remove(lastDelimiter, (ctfFilePath.Length - lastDelimiter));

          string ctfFileName = "Ploter.ctf";

          Stream embeddedCtfStream = null;

          String[] resourceStrings = assembly.GetManifestResourceNames();

          foreach (String name in resourceStrings)
          {
            if (name.Contains(ctfFileName))
            {
              embeddedCtfStream = assembly.GetManifestResourceStream(name);
              break;
            }
          }
          mcr= new MWMCR("",
                         ctfFilePath, embeddedCtfStream, true);
        }
        catch(Exception ex)
        {
          ex_ = new Exception("MWArray assembly failed to be initialized", ex);
        }
      }
      else
      {
        ex_ = new ApplicationException("MWArray assembly could not be initialized");
      }
    }


    /// <summary>
    /// Constructs a new instance of the Ploter class.
    /// </summary>
    public Ploter()
    {
      if(ex_ != null)
      {
        throw ex_;
      }
    }


    #endregion Constructors

    #region Finalize

    /// <summary internal= "true">
    /// Class destructor called by the CLR garbage collector.
    /// </summary>
    ~Ploter()
    {
      Dispose(false);
    }


    /// <summary>
    /// Frees the native resources associated with this object
    /// </summary>
    public void Dispose()
    {
      Dispose(true);

      GC.SuppressFinalize(this);
    }


    /// <summary internal= "true">
    /// Internal dispose function
    /// </summary>
    protected virtual void Dispose(bool disposing)
    {
      if (!disposed)
      {
        disposed= true;

        if (disposing)
        {
          // Free managed resources;
        }

        // Free native resources
      }
    }


    #endregion Finalize

    #region Methods

    /// <summary>
    /// Provides a void output, 0-input Objectinterface to the AxesDim MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    ///
    public void AxesDim()
    {
      mcr.EvaluateFunction(0, "AxesDim", new Object[]{});
    }


    /// <summary>
    /// Provides a void output, 1-input Objectinterface to the AxesDim MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    ///
    public void AxesDim(Object axeshandle)
    {
      mcr.EvaluateFunction(0, "AxesDim", axeshandle);
    }


    /// <summary>
    /// Provides a void output, 2-input Objectinterface to the AxesDim MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="minx">Input argument #2</param>
    ///
    public void AxesDim(Object axeshandle, Object minx)
    {
      mcr.EvaluateFunction(0, "AxesDim", axeshandle, minx);
    }


    /// <summary>
    /// Provides a void output, 3-input Objectinterface to the AxesDim MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="minx">Input argument #2</param>
    /// <param name="maxx">Input argument #3</param>
    ///
    public void AxesDim(Object axeshandle, Object minx, Object maxx)
    {
      mcr.EvaluateFunction(0, "AxesDim", axeshandle, minx, maxx);
    }


    /// <summary>
    /// Provides a void output, 4-input Objectinterface to the AxesDim MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="minx">Input argument #2</param>
    /// <param name="maxx">Input argument #3</param>
    /// <param name="miny">Input argument #4</param>
    ///
    public void AxesDim(Object axeshandle, Object minx, Object maxx, Object miny)
    {
      mcr.EvaluateFunction(0, "AxesDim", axeshandle, minx, maxx, miny);
    }


    /// <summary>
    /// Provides a void output, 5-input Objectinterface to the AxesDim MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="minx">Input argument #2</param>
    /// <param name="maxx">Input argument #3</param>
    /// <param name="miny">Input argument #4</param>
    /// <param name="maxy">Input argument #5</param>
    ///
    public void AxesDim(Object axeshandle, Object minx, Object maxx, Object miny, Object 
                  maxy)
    {
      mcr.EvaluateFunction(0, "AxesDim", axeshandle, minx, maxx, miny, maxy);
    }


    /// <summary>
    /// Provides the standard 0-input Object interface to the AxesDim MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] AxesDim(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "AxesDim", new Object[]{});
    }


    /// <summary>
    /// Provides the standard 1-input Object interface to the AxesDim MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] AxesDim(int numArgsOut, Object axeshandle)
    {
      return mcr.EvaluateFunction(numArgsOut, "AxesDim", axeshandle);
    }


    /// <summary>
    /// Provides the standard 2-input Object interface to the AxesDim MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="minx">Input argument #2</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] AxesDim(int numArgsOut, Object axeshandle, Object minx)
    {
      return mcr.EvaluateFunction(numArgsOut, "AxesDim", axeshandle, minx);
    }


    /// <summary>
    /// Provides the standard 3-input Object interface to the AxesDim MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="minx">Input argument #2</param>
    /// <param name="maxx">Input argument #3</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] AxesDim(int numArgsOut, Object axeshandle, Object minx, Object maxx)
    {
      return mcr.EvaluateFunction(numArgsOut, "AxesDim", axeshandle, minx, maxx);
    }


    /// <summary>
    /// Provides the standard 4-input Object interface to the AxesDim MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="minx">Input argument #2</param>
    /// <param name="maxx">Input argument #3</param>
    /// <param name="miny">Input argument #4</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] AxesDim(int numArgsOut, Object axeshandle, Object minx, Object maxx, 
                      Object miny)
    {
      return mcr.EvaluateFunction(numArgsOut, "AxesDim", axeshandle, minx, maxx, miny);
    }


    /// <summary>
    /// Provides the standard 5-input Object interface to the AxesDim MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="minx">Input argument #2</param>
    /// <param name="maxx">Input argument #3</param>
    /// <param name="miny">Input argument #4</param>
    /// <param name="maxy">Input argument #5</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] AxesDim(int numArgsOut, Object axeshandle, Object minx, Object maxx, 
                      Object miny, Object maxy)
    {
      return mcr.EvaluateFunction(numArgsOut, "AxesDim", axeshandle, minx, maxx, miny, maxy);
    }


    /// <summary>
    /// Provides an interface for the AxesDim function in which the input and output
    /// arguments are specified as an array of Objects.
    /// </summary>
    /// <remarks>
    /// This method will allocate and return by reference the output argument
    /// array.<newpara></newpara>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return</param>
    /// <param name= "argsOut">Array of Object output arguments</param>
    /// <param name= "argsIn">Array of Object input arguments</param>
    /// <param name= "varArgsIn">Array of Object representing variable input
    /// arguments</param>
    ///
    [MATLABSignature("AxesDim", 5, 0, 0)]
    protected void AxesDim(int numArgsOut, ref Object[] argsOut, Object[] argsIn, params Object[] varArgsIn)
    {
        mcr.EvaluateFunctionForTypeSafeCall("AxesDim", numArgsOut, ref argsOut, argsIn, varArgsIn);
    }
    /// <summary>
    /// Provides a void output, 0-input Objectinterface to the ChangeAxes MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    ///
    public void ChangeAxes()
    {
      mcr.EvaluateFunction(0, "ChangeAxes", new Object[]{});
    }


    /// <summary>
    /// Provides a void output, 1-input Objectinterface to the ChangeAxes MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    ///
    public void ChangeAxes(Object axeshandle)
    {
      mcr.EvaluateFunction(0, "ChangeAxes", axeshandle);
    }


    /// <summary>
    /// Provides the standard 0-input Object interface to the ChangeAxes MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] ChangeAxes(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "ChangeAxes", new Object[]{});
    }


    /// <summary>
    /// Provides the standard 1-input Object interface to the ChangeAxes MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] ChangeAxes(int numArgsOut, Object axeshandle)
    {
      return mcr.EvaluateFunction(numArgsOut, "ChangeAxes", axeshandle);
    }


    /// <summary>
    /// Provides an interface for the ChangeAxes function in which the input and output
    /// arguments are specified as an array of Objects.
    /// </summary>
    /// <remarks>
    /// This method will allocate and return by reference the output argument
    /// array.<newpara></newpara>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return</param>
    /// <param name= "argsOut">Array of Object output arguments</param>
    /// <param name= "argsIn">Array of Object input arguments</param>
    /// <param name= "varArgsIn">Array of Object representing variable input
    /// arguments</param>
    ///
    [MATLABSignature("ChangeAxes", 1, 0, 0)]
    protected void ChangeAxes(int numArgsOut, ref Object[] argsOut, Object[] argsIn, params Object[] varArgsIn)
    {
        mcr.EvaluateFunctionForTypeSafeCall("ChangeAxes", numArgsOut, ref argsOut, argsIn, varArgsIn);
    }
    /// <summary>
    /// Provides a void output, 0-input Objectinterface to the ClearAxes MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    ///
    public void ClearAxes()
    {
      mcr.EvaluateFunction(0, "ClearAxes", new Object[]{});
    }


    /// <summary>
    /// Provides a void output, 1-input Objectinterface to the ClearAxes MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    ///
    public void ClearAxes(Object axeshandle)
    {
      mcr.EvaluateFunction(0, "ClearAxes", axeshandle);
    }


    /// <summary>
    /// Provides the standard 0-input Object interface to the ClearAxes MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] ClearAxes(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "ClearAxes", new Object[]{});
    }


    /// <summary>
    /// Provides the standard 1-input Object interface to the ClearAxes MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] ClearAxes(int numArgsOut, Object axeshandle)
    {
      return mcr.EvaluateFunction(numArgsOut, "ClearAxes", axeshandle);
    }


    /// <summary>
    /// Provides an interface for the ClearAxes function in which the input and output
    /// arguments are specified as an array of Objects.
    /// </summary>
    /// <remarks>
    /// This method will allocate and return by reference the output argument
    /// array.<newpara></newpara>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return</param>
    /// <param name= "argsOut">Array of Object output arguments</param>
    /// <param name= "argsIn">Array of Object input arguments</param>
    /// <param name= "varArgsIn">Array of Object representing variable input
    /// arguments</param>
    ///
    [MATLABSignature("ClearAxes", 1, 0, 0)]
    protected void ClearAxes(int numArgsOut, ref Object[] argsOut, Object[] argsIn, params Object[] varArgsIn)
    {
        mcr.EvaluateFunctionForTypeSafeCall("ClearAxes", numArgsOut, ref argsOut, argsIn, varArgsIn);
    }
    /// <summary>
    /// Provides a void output, 0-input Objectinterface to the CloseFigure MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    ///
    public void CloseFigure()
    {
      mcr.EvaluateFunction(0, "CloseFigure", new Object[]{});
    }


    /// <summary>
    /// Provides a void output, 1-input Objectinterface to the CloseFigure MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    ///
    public void CloseFigure(Object axeshandle)
    {
      mcr.EvaluateFunction(0, "CloseFigure", axeshandle);
    }


    /// <summary>
    /// Provides the standard 0-input Object interface to the CloseFigure MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] CloseFigure(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "CloseFigure", new Object[]{});
    }


    /// <summary>
    /// Provides the standard 1-input Object interface to the CloseFigure MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] CloseFigure(int numArgsOut, Object axeshandle)
    {
      return mcr.EvaluateFunction(numArgsOut, "CloseFigure", axeshandle);
    }


    /// <summary>
    /// Provides an interface for the CloseFigure function in which the input and output
    /// arguments are specified as an array of Objects.
    /// </summary>
    /// <remarks>
    /// This method will allocate and return by reference the output argument
    /// array.<newpara></newpara>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return</param>
    /// <param name= "argsOut">Array of Object output arguments</param>
    /// <param name= "argsIn">Array of Object input arguments</param>
    /// <param name= "varArgsIn">Array of Object representing variable input
    /// arguments</param>
    ///
    [MATLABSignature("CloseFigure", 1, 0, 0)]
    protected void CloseFigure(int numArgsOut, ref Object[] argsOut, Object[] argsIn, params Object[] varArgsIn)
    {
        mcr.EvaluateFunctionForTypeSafeCall("CloseFigure", numArgsOut, ref argsOut, argsIn, varArgsIn);
    }
    /// <summary>
    /// Provides a single output, 0-input Objectinterface to the FindStreetPosition
    /// MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object FindStreetPosition()
    {
      return mcr.EvaluateFunction("FindStreetPosition", new Object[]{});
    }


    /// <summary>
    /// Provides a single output, 1-input Objectinterface to the FindStreetPosition
    /// MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="pos1x">Input argument #1</param>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object FindStreetPosition(Object pos1x)
    {
      return mcr.EvaluateFunction("FindStreetPosition", pos1x);
    }


    /// <summary>
    /// Provides a single output, 2-input Objectinterface to the FindStreetPosition
    /// MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object FindStreetPosition(Object pos1x, Object pos1y)
    {
      return mcr.EvaluateFunction("FindStreetPosition", pos1x, pos1y);
    }


    /// <summary>
    /// Provides a single output, 3-input Objectinterface to the FindStreetPosition
    /// MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <param name="pos2x">Input argument #3</param>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object FindStreetPosition(Object pos1x, Object pos1y, Object pos2x)
    {
      return mcr.EvaluateFunction("FindStreetPosition", pos1x, pos1y, pos2x);
    }


    /// <summary>
    /// Provides a single output, 4-input Objectinterface to the FindStreetPosition
    /// MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <param name="pos2x">Input argument #3</param>
    /// <param name="pos2y">Input argument #4</param>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object FindStreetPosition(Object pos1x, Object pos1y, Object pos2x, Object 
                               pos2y)
    {
      return mcr.EvaluateFunction("FindStreetPosition", pos1x, pos1y, pos2x, pos2y);
    }


    /// <summary>
    /// Provides a single output, 5-input Objectinterface to the FindStreetPosition
    /// MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <param name="pos2x">Input argument #3</param>
    /// <param name="pos2y">Input argument #4</param>
    /// <param name="radius">Input argument #5</param>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object FindStreetPosition(Object pos1x, Object pos1y, Object pos2x, Object 
                               pos2y, Object radius)
    {
      return mcr.EvaluateFunction("FindStreetPosition", pos1x, pos1y, pos2x, pos2y, radius);
    }


    /// <summary>
    /// Provides a single output, 6-input Objectinterface to the FindStreetPosition
    /// MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <param name="pos2x">Input argument #3</param>
    /// <param name="pos2y">Input argument #4</param>
    /// <param name="radius">Input argument #5</param>
    /// <param name="angle">Input argument #6</param>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object FindStreetPosition(Object pos1x, Object pos1y, Object pos2x, Object 
                               pos2y, Object radius, Object angle)
    {
      return mcr.EvaluateFunction("FindStreetPosition", pos1x, pos1y, pos2x, pos2y, radius, angle);
    }


    /// <summary>
    /// Provides the standard 0-input Object interface to the FindStreetPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] FindStreetPosition(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "FindStreetPosition", new Object[]{});
    }


    /// <summary>
    /// Provides the standard 1-input Object interface to the FindStreetPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="pos1x">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] FindStreetPosition(int numArgsOut, Object pos1x)
    {
      return mcr.EvaluateFunction(numArgsOut, "FindStreetPosition", pos1x);
    }


    /// <summary>
    /// Provides the standard 2-input Object interface to the FindStreetPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] FindStreetPosition(int numArgsOut, Object pos1x, Object pos1y)
    {
      return mcr.EvaluateFunction(numArgsOut, "FindStreetPosition", pos1x, pos1y);
    }


    /// <summary>
    /// Provides the standard 3-input Object interface to the FindStreetPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <param name="pos2x">Input argument #3</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] FindStreetPosition(int numArgsOut, Object pos1x, Object pos1y, Object 
                                 pos2x)
    {
      return mcr.EvaluateFunction(numArgsOut, "FindStreetPosition", pos1x, pos1y, pos2x);
    }


    /// <summary>
    /// Provides the standard 4-input Object interface to the FindStreetPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <param name="pos2x">Input argument #3</param>
    /// <param name="pos2y">Input argument #4</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] FindStreetPosition(int numArgsOut, Object pos1x, Object pos1y, Object 
                                 pos2x, Object pos2y)
    {
      return mcr.EvaluateFunction(numArgsOut, "FindStreetPosition", pos1x, pos1y, pos2x, pos2y);
    }


    /// <summary>
    /// Provides the standard 5-input Object interface to the FindStreetPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <param name="pos2x">Input argument #3</param>
    /// <param name="pos2y">Input argument #4</param>
    /// <param name="radius">Input argument #5</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] FindStreetPosition(int numArgsOut, Object pos1x, Object pos1y, Object 
                                 pos2x, Object pos2y, Object radius)
    {
      return mcr.EvaluateFunction(numArgsOut, "FindStreetPosition", pos1x, pos1y, pos2x, pos2y, radius);
    }


    /// <summary>
    /// Provides the standard 6-input Object interface to the FindStreetPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <param name="pos2x">Input argument #3</param>
    /// <param name="pos2y">Input argument #4</param>
    /// <param name="radius">Input argument #5</param>
    /// <param name="angle">Input argument #6</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] FindStreetPosition(int numArgsOut, Object pos1x, Object pos1y, Object 
                                 pos2x, Object pos2y, Object radius, Object angle)
    {
      return mcr.EvaluateFunction(numArgsOut, "FindStreetPosition", pos1x, pos1y, pos2x, pos2y, radius, angle);
    }


    /// <summary>
    /// Provides an interface for the FindStreetPosition function in which the input and
    /// output
    /// arguments are specified as an array of Objects.
    /// </summary>
    /// <remarks>
    /// This method will allocate and return by reference the output argument
    /// array.<newpara></newpara>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return</param>
    /// <param name= "argsOut">Array of Object output arguments</param>
    /// <param name= "argsIn">Array of Object input arguments</param>
    /// <param name= "varArgsIn">Array of Object representing variable input
    /// arguments</param>
    ///
    [MATLABSignature("FindStreetPosition", 6, 6, 0)]
    protected void FindStreetPosition(int numArgsOut, ref Object[] argsOut, Object[] argsIn, params Object[] varArgsIn)
    {
        mcr.EvaluateFunctionForTypeSafeCall("FindStreetPosition", numArgsOut, ref argsOut, argsIn, varArgsIn);
    }
    /// <summary>
    /// Provides a single output, 0-input Objectinterface to the FindTLPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object FindTLPosition()
    {
      return mcr.EvaluateFunction("FindTLPosition", new Object[]{});
    }


    /// <summary>
    /// Provides a single output, 1-input Objectinterface to the FindTLPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="pos1x">Input argument #1</param>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object FindTLPosition(Object pos1x)
    {
      return mcr.EvaluateFunction("FindTLPosition", pos1x);
    }


    /// <summary>
    /// Provides a single output, 2-input Objectinterface to the FindTLPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object FindTLPosition(Object pos1x, Object pos1y)
    {
      return mcr.EvaluateFunction("FindTLPosition", pos1x, pos1y);
    }


    /// <summary>
    /// Provides a single output, 3-input Objectinterface to the FindTLPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <param name="pos2x">Input argument #3</param>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object FindTLPosition(Object pos1x, Object pos1y, Object pos2x)
    {
      return mcr.EvaluateFunction("FindTLPosition", pos1x, pos1y, pos2x);
    }


    /// <summary>
    /// Provides a single output, 4-input Objectinterface to the FindTLPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <param name="pos2x">Input argument #3</param>
    /// <param name="pos2y">Input argument #4</param>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object FindTLPosition(Object pos1x, Object pos1y, Object pos2x, Object pos2y)
    {
      return mcr.EvaluateFunction("FindTLPosition", pos1x, pos1y, pos2x, pos2y);
    }


    /// <summary>
    /// Provides a single output, 5-input Objectinterface to the FindTLPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <param name="pos2x">Input argument #3</param>
    /// <param name="pos2y">Input argument #4</param>
    /// <param name="radius">Input argument #5</param>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object FindTLPosition(Object pos1x, Object pos1y, Object pos2x, Object pos2y, 
                           Object radius)
    {
      return mcr.EvaluateFunction("FindTLPosition", pos1x, pos1y, pos2x, pos2y, radius);
    }


    /// <summary>
    /// Provides the standard 0-input Object interface to the FindTLPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] FindTLPosition(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "FindTLPosition", new Object[]{});
    }


    /// <summary>
    /// Provides the standard 1-input Object interface to the FindTLPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="pos1x">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] FindTLPosition(int numArgsOut, Object pos1x)
    {
      return mcr.EvaluateFunction(numArgsOut, "FindTLPosition", pos1x);
    }


    /// <summary>
    /// Provides the standard 2-input Object interface to the FindTLPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] FindTLPosition(int numArgsOut, Object pos1x, Object pos1y)
    {
      return mcr.EvaluateFunction(numArgsOut, "FindTLPosition", pos1x, pos1y);
    }


    /// <summary>
    /// Provides the standard 3-input Object interface to the FindTLPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <param name="pos2x">Input argument #3</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] FindTLPosition(int numArgsOut, Object pos1x, Object pos1y, Object 
                             pos2x)
    {
      return mcr.EvaluateFunction(numArgsOut, "FindTLPosition", pos1x, pos1y, pos2x);
    }


    /// <summary>
    /// Provides the standard 4-input Object interface to the FindTLPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <param name="pos2x">Input argument #3</param>
    /// <param name="pos2y">Input argument #4</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] FindTLPosition(int numArgsOut, Object pos1x, Object pos1y, Object 
                             pos2x, Object pos2y)
    {
      return mcr.EvaluateFunction(numArgsOut, "FindTLPosition", pos1x, pos1y, pos2x, pos2y);
    }


    /// <summary>
    /// Provides the standard 5-input Object interface to the FindTLPosition MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="pos1x">Input argument #1</param>
    /// <param name="pos1y">Input argument #2</param>
    /// <param name="pos2x">Input argument #3</param>
    /// <param name="pos2y">Input argument #4</param>
    /// <param name="radius">Input argument #5</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] FindTLPosition(int numArgsOut, Object pos1x, Object pos1y, Object 
                             pos2x, Object pos2y, Object radius)
    {
      return mcr.EvaluateFunction(numArgsOut, "FindTLPosition", pos1x, pos1y, pos2x, pos2y, radius);
    }


    /// <summary>
    /// Provides an interface for the FindTLPosition function in which the input and
    /// output
    /// arguments are specified as an array of Objects.
    /// </summary>
    /// <remarks>
    /// This method will allocate and return by reference the output argument
    /// array.<newpara></newpara>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return</param>
    /// <param name= "argsOut">Array of Object output arguments</param>
    /// <param name= "argsIn">Array of Object input arguments</param>
    /// <param name= "varArgsIn">Array of Object representing variable input
    /// arguments</param>
    ///
    [MATLABSignature("FindTLPosition", 5, 2, 0)]
    protected void FindTLPosition(int numArgsOut, ref Object[] argsOut, Object[] argsIn, params Object[] varArgsIn)
    {
        mcr.EvaluateFunctionForTypeSafeCall("FindTLPosition", numArgsOut, ref argsOut, argsIn, varArgsIn);
    }
    /// <summary>
    /// Provides a void output, 0-input Objectinterface to the HeatScale MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    ///
    public void HeatScale()
    {
      mcr.EvaluateFunction(0, "HeatScale", new Object[]{});
    }


    /// <summary>
    /// Provides a void output, 1-input Objectinterface to the HeatScale MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    ///
    public void HeatScale(Object axeshandle)
    {
      mcr.EvaluateFunction(0, "HeatScale", axeshandle);
    }


    /// <summary>
    /// Provides a void output, 2-input Objectinterface to the HeatScale MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="posx">Input argument #2</param>
    ///
    public void HeatScale(Object axeshandle, Object posx)
    {
      mcr.EvaluateFunction(0, "HeatScale", axeshandle, posx);
    }


    /// <summary>
    /// Provides a void output, 3-input Objectinterface to the HeatScale MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="posx">Input argument #2</param>
    /// <param name="posy">Input argument #3</param>
    ///
    public void HeatScale(Object axeshandle, Object posx, Object posy)
    {
      mcr.EvaluateFunction(0, "HeatScale", axeshandle, posx, posy);
    }


    /// <summary>
    /// Provides a void output, 4-input Objectinterface to the HeatScale MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="posx">Input argument #2</param>
    /// <param name="posy">Input argument #3</param>
    /// <param name="width">Input argument #4</param>
    ///
    public void HeatScale(Object axeshandle, Object posx, Object posy, Object width)
    {
      mcr.EvaluateFunction(0, "HeatScale", axeshandle, posx, posy, width);
    }


    /// <summary>
    /// Provides a void output, 5-input Objectinterface to the HeatScale MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="posx">Input argument #2</param>
    /// <param name="posy">Input argument #3</param>
    /// <param name="width">Input argument #4</param>
    /// <param name="height">Input argument #5</param>
    ///
    public void HeatScale(Object axeshandle, Object posx, Object posy, Object width, 
                    Object height)
    {
      mcr.EvaluateFunction(0, "HeatScale", axeshandle, posx, posy, width, height);
    }


    /// <summary>
    /// Provides the standard 0-input Object interface to the HeatScale MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] HeatScale(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "HeatScale", new Object[]{});
    }


    /// <summary>
    /// Provides the standard 1-input Object interface to the HeatScale MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] HeatScale(int numArgsOut, Object axeshandle)
    {
      return mcr.EvaluateFunction(numArgsOut, "HeatScale", axeshandle);
    }


    /// <summary>
    /// Provides the standard 2-input Object interface to the HeatScale MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="posx">Input argument #2</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] HeatScale(int numArgsOut, Object axeshandle, Object posx)
    {
      return mcr.EvaluateFunction(numArgsOut, "HeatScale", axeshandle, posx);
    }


    /// <summary>
    /// Provides the standard 3-input Object interface to the HeatScale MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="posx">Input argument #2</param>
    /// <param name="posy">Input argument #3</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] HeatScale(int numArgsOut, Object axeshandle, Object posx, Object posy)
    {
      return mcr.EvaluateFunction(numArgsOut, "HeatScale", axeshandle, posx, posy);
    }


    /// <summary>
    /// Provides the standard 4-input Object interface to the HeatScale MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="posx">Input argument #2</param>
    /// <param name="posy">Input argument #3</param>
    /// <param name="width">Input argument #4</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] HeatScale(int numArgsOut, Object axeshandle, Object posx, Object 
                        posy, Object width)
    {
      return mcr.EvaluateFunction(numArgsOut, "HeatScale", axeshandle, posx, posy, width);
    }


    /// <summary>
    /// Provides the standard 5-input Object interface to the HeatScale MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="posx">Input argument #2</param>
    /// <param name="posy">Input argument #3</param>
    /// <param name="width">Input argument #4</param>
    /// <param name="height">Input argument #5</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] HeatScale(int numArgsOut, Object axeshandle, Object posx, Object 
                        posy, Object width, Object height)
    {
      return mcr.EvaluateFunction(numArgsOut, "HeatScale", axeshandle, posx, posy, width, height);
    }


    /// <summary>
    /// Provides an interface for the HeatScale function in which the input and output
    /// arguments are specified as an array of Objects.
    /// </summary>
    /// <remarks>
    /// This method will allocate and return by reference the output argument
    /// array.<newpara></newpara>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return</param>
    /// <param name= "argsOut">Array of Object output arguments</param>
    /// <param name= "argsIn">Array of Object input arguments</param>
    /// <param name= "varArgsIn">Array of Object representing variable input
    /// arguments</param>
    ///
    [MATLABSignature("HeatScale", 5, 0, 0)]
    protected void HeatScale(int numArgsOut, ref Object[] argsOut, Object[] argsIn, params Object[] varArgsIn)
    {
        mcr.EvaluateFunctionForTypeSafeCall("HeatScale", numArgsOut, ref argsOut, argsIn, varArgsIn);
    }
    /// <summary>
    /// Provides a single output, 0-input Objectinterface to the OpenFigure MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// jFrame=get(fighandle,'javaframe');
    /// jIcon=javax.swing.ImageIcon('TrafficLight.ico');
    /// jFrame.setFigureIcon(jIcon);
    /// </remarks>
    /// <returns>An Object containing the first output argument.</returns>
    ///
    public Object OpenFigure()
    {
      return mcr.EvaluateFunction("OpenFigure", new Object[]{});
    }


    /// <summary>
    /// Provides the standard 0-input Object interface to the OpenFigure MATLAB function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// jFrame=get(fighandle,'javaframe');
    /// jIcon=javax.swing.ImageIcon('TrafficLight.ico');
    /// jFrame.setFigureIcon(jIcon);
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] OpenFigure(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "OpenFigure", new Object[]{});
    }


    /// <summary>
    /// Provides an interface for the OpenFigure function in which the input and output
    /// arguments are specified as an array of Objects.
    /// </summary>
    /// <remarks>
    /// This method will allocate and return by reference the output argument
    /// array.<newpara></newpara>
    /// M-Documentation:
    /// jFrame=get(fighandle,'javaframe');
    /// jIcon=javax.swing.ImageIcon('TrafficLight.ico');
    /// jFrame.setFigureIcon(jIcon);
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return</param>
    /// <param name= "argsOut">Array of Object output arguments</param>
    /// <param name= "argsIn">Array of Object input arguments</param>
    /// <param name= "varArgsIn">Array of Object representing variable input
    /// arguments</param>
    ///
    [MATLABSignature("OpenFigure", 0, 2, 0)]
    protected void OpenFigure(int numArgsOut, ref Object[] argsOut, Object[] argsIn, params Object[] varArgsIn)
    {
        mcr.EvaluateFunctionForTypeSafeCall("OpenFigure", numArgsOut, ref argsOut, argsIn, varArgsIn);
    }
    /// <summary>
    /// Provides a void output, 0-input Objectinterface to the PlotCar MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    ///
    public void PlotCar()
    {
      mcr.EvaluateFunction(0, "PlotCar", new Object[]{});
    }


    /// <summary>
    /// Provides a void output, 1-input Objectinterface to the PlotCar MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="varargin">Array of Objects representing the input arguments 1
    /// through varargin.length</param>
    ///
    public void PlotCar(params Object[] varargin)
    {
      mcr.EvaluateFunction(0, "PlotCar", varargin);
    }


    /// <summary>
    /// Provides the standard 0-input Object interface to the PlotCar MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotCar(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotCar", new Object[]{});
    }


    /// <summary>
    /// Provides the standard 1-input Object interface to the PlotCar MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="varargin">Array of Objects representing the input arguments 1
    /// through varargin.length</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotCar(int numArgsOut, params Object[] varargin)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotCar", varargin);
    }


    /// <summary>
    /// Provides an interface for the PlotCar function in which the input and output
    /// arguments are specified as an array of Objects.
    /// </summary>
    /// <remarks>
    /// This method will allocate and return by reference the output argument
    /// array.<newpara></newpara>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return</param>
    /// <param name= "argsOut">Array of Object output arguments</param>
    /// <param name= "argsIn">Array of Object input arguments</param>
    /// <param name= "varArgsIn">Array of Object representing variable input
    /// arguments</param>
    ///
    [MATLABSignature("PlotCar", 0, 0, 1)]
    protected void PlotCar(int numArgsOut, ref Object[] argsOut, Object[] argsIn, params Object[] varArgsIn)
    {
        mcr.EvaluateFunctionForTypeSafeCall("PlotCar", numArgsOut, ref argsOut, argsIn, varArgsIn);
    }
    /// <summary>
    /// Provides a void output, 0-input Objectinterface to the PlotCircle1 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    ///
    public void PlotCircle1()
    {
      mcr.EvaluateFunction(0, "PlotCircle1", new Object[]{});
    }


    /// <summary>
    /// Provides a void output, 1-input Objectinterface to the PlotCircle1 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="posx">Input argument #1</param>
    ///
    public void PlotCircle1(Object posx)
    {
      mcr.EvaluateFunction(0, "PlotCircle1", posx);
    }


    /// <summary>
    /// Provides a void output, 2-input Objectinterface to the PlotCircle1 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="posx">Input argument #1</param>
    /// <param name="posy">Input argument #2</param>
    ///
    public void PlotCircle1(Object posx, Object posy)
    {
      mcr.EvaluateFunction(0, "PlotCircle1", posx, posy);
    }


    /// <summary>
    /// Provides a void output, 3-input Objectinterface to the PlotCircle1 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="posx">Input argument #1</param>
    /// <param name="posy">Input argument #2</param>
    /// <param name="radius">Input argument #3</param>
    ///
    public void PlotCircle1(Object posx, Object posy, Object radius)
    {
      mcr.EvaluateFunction(0, "PlotCircle1", posx, posy, radius);
    }


    /// <summary>
    /// Provides the standard 0-input Object interface to the PlotCircle1 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotCircle1(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotCircle1", new Object[]{});
    }


    /// <summary>
    /// Provides the standard 1-input Object interface to the PlotCircle1 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="posx">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotCircle1(int numArgsOut, Object posx)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotCircle1", posx);
    }


    /// <summary>
    /// Provides the standard 2-input Object interface to the PlotCircle1 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="posx">Input argument #1</param>
    /// <param name="posy">Input argument #2</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotCircle1(int numArgsOut, Object posx, Object posy)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotCircle1", posx, posy);
    }


    /// <summary>
    /// Provides the standard 3-input Object interface to the PlotCircle1 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="posx">Input argument #1</param>
    /// <param name="posy">Input argument #2</param>
    /// <param name="radius">Input argument #3</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotCircle1(int numArgsOut, Object posx, Object posy, Object radius)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotCircle1", posx, posy, radius);
    }


    /// <summary>
    /// Provides an interface for the PlotCircle1 function in which the input and output
    /// arguments are specified as an array of Objects.
    /// </summary>
    /// <remarks>
    /// This method will allocate and return by reference the output argument
    /// array.<newpara></newpara>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return</param>
    /// <param name= "argsOut">Array of Object output arguments</param>
    /// <param name= "argsIn">Array of Object input arguments</param>
    /// <param name= "varArgsIn">Array of Object representing variable input
    /// arguments</param>
    ///
    [MATLABSignature("PlotCircle1", 3, 0, 0)]
    protected void PlotCircle1(int numArgsOut, ref Object[] argsOut, Object[] argsIn, params Object[] varArgsIn)
    {
        mcr.EvaluateFunctionForTypeSafeCall("PlotCircle1", numArgsOut, ref argsOut, argsIn, varArgsIn);
    }
    /// <summary>
    /// Provides a void output, 0-input Objectinterface to the PlotCircle2 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    ///
    public void PlotCircle2()
    {
      mcr.EvaluateFunction(0, "PlotCircle2", new Object[]{});
    }


    /// <summary>
    /// Provides a void output, 1-input Objectinterface to the PlotCircle2 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="posx">Input argument #1</param>
    ///
    public void PlotCircle2(Object posx)
    {
      mcr.EvaluateFunction(0, "PlotCircle2", posx);
    }


    /// <summary>
    /// Provides a void output, 2-input Objectinterface to the PlotCircle2 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="posx">Input argument #1</param>
    /// <param name="posy">Input argument #2</param>
    ///
    public void PlotCircle2(Object posx, Object posy)
    {
      mcr.EvaluateFunction(0, "PlotCircle2", posx, posy);
    }


    /// <summary>
    /// Provides a void output, 3-input Objectinterface to the PlotCircle2 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="posx">Input argument #1</param>
    /// <param name="posy">Input argument #2</param>
    /// <param name="radius">Input argument #3</param>
    ///
    public void PlotCircle2(Object posx, Object posy, Object radius)
    {
      mcr.EvaluateFunction(0, "PlotCircle2", posx, posy, radius);
    }


    /// <summary>
    /// Provides a void output, 4-input Objectinterface to the PlotCircle2 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="posx">Input argument #1</param>
    /// <param name="posy">Input argument #2</param>
    /// <param name="radius">Input argument #3</param>
    /// <param name="szazalek">Input argument #4</param>
    ///
    public void PlotCircle2(Object posx, Object posy, Object radius, Object szazalek)
    {
      mcr.EvaluateFunction(0, "PlotCircle2", posx, posy, radius, szazalek);
    }


    /// <summary>
    /// Provides the standard 0-input Object interface to the PlotCircle2 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotCircle2(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotCircle2", new Object[]{});
    }


    /// <summary>
    /// Provides the standard 1-input Object interface to the PlotCircle2 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="posx">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotCircle2(int numArgsOut, Object posx)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotCircle2", posx);
    }


    /// <summary>
    /// Provides the standard 2-input Object interface to the PlotCircle2 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="posx">Input argument #1</param>
    /// <param name="posy">Input argument #2</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotCircle2(int numArgsOut, Object posx, Object posy)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotCircle2", posx, posy);
    }


    /// <summary>
    /// Provides the standard 3-input Object interface to the PlotCircle2 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="posx">Input argument #1</param>
    /// <param name="posy">Input argument #2</param>
    /// <param name="radius">Input argument #3</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotCircle2(int numArgsOut, Object posx, Object posy, Object radius)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotCircle2", posx, posy, radius);
    }


    /// <summary>
    /// Provides the standard 4-input Object interface to the PlotCircle2 MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="posx">Input argument #1</param>
    /// <param name="posy">Input argument #2</param>
    /// <param name="radius">Input argument #3</param>
    /// <param name="szazalek">Input argument #4</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotCircle2(int numArgsOut, Object posx, Object posy, Object radius, 
                          Object szazalek)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotCircle2", posx, posy, radius, szazalek);
    }


    /// <summary>
    /// Provides an interface for the PlotCircle2 function in which the input and output
    /// arguments are specified as an array of Objects.
    /// </summary>
    /// <remarks>
    /// This method will allocate and return by reference the output argument
    /// array.<newpara></newpara>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return</param>
    /// <param name= "argsOut">Array of Object output arguments</param>
    /// <param name= "argsIn">Array of Object input arguments</param>
    /// <param name= "varArgsIn">Array of Object representing variable input
    /// arguments</param>
    ///
    [MATLABSignature("PlotCircle2", 4, 0, 0)]
    protected void PlotCircle2(int numArgsOut, ref Object[] argsOut, Object[] argsIn, params Object[] varArgsIn)
    {
        mcr.EvaluateFunctionForTypeSafeCall("PlotCircle2", numArgsOut, ref argsOut, argsIn, varArgsIn);
    }
    /// <summary>
    /// Provides a void output, 0-input Objectinterface to the PlotIteration MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    ///
    public void PlotIteration()
    {
      mcr.EvaluateFunction(0, "PlotIteration", new Object[]{});
    }


    /// <summary>
    /// Provides a void output, 1-input Objectinterface to the PlotIteration MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axes1">Input argument #1</param>
    ///
    public void PlotIteration(Object axes1)
    {
      mcr.EvaluateFunction(0, "PlotIteration", axes1);
    }


    /// <summary>
    /// Provides a void output, 2-input Objectinterface to the PlotIteration MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axes1">Input argument #1</param>
    /// <param name="axes2">Input argument #2</param>
    ///
    public void PlotIteration(Object axes1, Object axes2)
    {
      mcr.EvaluateFunction(0, "PlotIteration", axes1, axes2);
    }


    /// <summary>
    /// Provides a void output, 3-input Objectinterface to the PlotIteration MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axes1">Input argument #1</param>
    /// <param name="axes2">Input argument #2</param>
    /// <param name="db1">Input argument #3</param>
    ///
    public void PlotIteration(Object axes1, Object axes2, Object db1)
    {
      mcr.EvaluateFunction(0, "PlotIteration", axes1, axes2, db1);
    }


    /// <summary>
    /// Provides a void output, 4-input Objectinterface to the PlotIteration MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axes1">Input argument #1</param>
    /// <param name="axes2">Input argument #2</param>
    /// <param name="db1">Input argument #3</param>
    /// <param name="db2">Input argument #4</param>
    ///
    public void PlotIteration(Object axes1, Object axes2, Object db1, Object db2)
    {
      mcr.EvaluateFunction(0, "PlotIteration", axes1, axes2, db1, db2);
    }


    /// <summary>
    /// Provides a void output, 5-input Objectinterface to the PlotIteration MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axes1">Input argument #1</param>
    /// <param name="axes2">Input argument #2</param>
    /// <param name="db1">Input argument #3</param>
    /// <param name="db2">Input argument #4</param>
    /// <param name="radius">Input argument #5</param>
    ///
    public void PlotIteration(Object axes1, Object axes2, Object db1, Object db2, Object 
                        radius)
    {
      mcr.EvaluateFunction(0, "PlotIteration", axes1, axes2, db1, db2, radius);
    }


    /// <summary>
    /// Provides a void output, 6-input Objectinterface to the PlotIteration MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axes1">Input argument #1</param>
    /// <param name="axes2">Input argument #2</param>
    /// <param name="db1">Input argument #3</param>
    /// <param name="db2">Input argument #4</param>
    /// <param name="radius">Input argument #5</param>
    /// <param name="varargin">Array of Objects representing the input arguments 6
    /// through varargin.length+5</param>
    ///
    public void PlotIteration(Object axes1, Object axes2, Object db1, Object db2, Object 
                        radius, params Object[] varargin)
    {
      Object[] argsIn= {axes1, axes2, db1, db2, radius, varargin};

      mcr.EvaluateFunction(0, "PlotIteration", argsIn);
    }


    /// <summary>
    /// Provides the standard 0-input Object interface to the PlotIteration MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotIteration(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotIteration", new Object[]{});
    }


    /// <summary>
    /// Provides the standard 1-input Object interface to the PlotIteration MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axes1">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotIteration(int numArgsOut, Object axes1)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotIteration", axes1);
    }


    /// <summary>
    /// Provides the standard 2-input Object interface to the PlotIteration MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axes1">Input argument #1</param>
    /// <param name="axes2">Input argument #2</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotIteration(int numArgsOut, Object axes1, Object axes2)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotIteration", axes1, axes2);
    }


    /// <summary>
    /// Provides the standard 3-input Object interface to the PlotIteration MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axes1">Input argument #1</param>
    /// <param name="axes2">Input argument #2</param>
    /// <param name="db1">Input argument #3</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotIteration(int numArgsOut, Object axes1, Object axes2, Object db1)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotIteration", axes1, axes2, db1);
    }


    /// <summary>
    /// Provides the standard 4-input Object interface to the PlotIteration MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axes1">Input argument #1</param>
    /// <param name="axes2">Input argument #2</param>
    /// <param name="db1">Input argument #3</param>
    /// <param name="db2">Input argument #4</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotIteration(int numArgsOut, Object axes1, Object axes2, Object db1, 
                            Object db2)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotIteration", axes1, axes2, db1, db2);
    }


    /// <summary>
    /// Provides the standard 5-input Object interface to the PlotIteration MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axes1">Input argument #1</param>
    /// <param name="axes2">Input argument #2</param>
    /// <param name="db1">Input argument #3</param>
    /// <param name="db2">Input argument #4</param>
    /// <param name="radius">Input argument #5</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotIteration(int numArgsOut, Object axes1, Object axes2, Object db1, 
                            Object db2, Object radius)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotIteration", axes1, axes2, db1, db2, radius);
    }


    /// <summary>
    /// Provides the standard 6-input Object interface to the PlotIteration MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axes1">Input argument #1</param>
    /// <param name="axes2">Input argument #2</param>
    /// <param name="db1">Input argument #3</param>
    /// <param name="db2">Input argument #4</param>
    /// <param name="radius">Input argument #5</param>
    /// <param name="varargin">Array of Objects representing the input arguments 6
    /// through varargin.length+5</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotIteration(int numArgsOut, Object axes1, Object axes2, Object db1, 
                            Object db2, Object radius, params Object[] varargin)
    {
      Object[] argsIn= {axes1, axes2, db1, db2, radius, varargin};

      return mcr.EvaluateFunction(numArgsOut, "PlotIteration", argsIn);
    }


    /// <summary>
    /// Provides an interface for the PlotIteration function in which the input and
    /// output
    /// arguments are specified as an array of Objects.
    /// </summary>
    /// <remarks>
    /// This method will allocate and return by reference the output argument
    /// array.<newpara></newpara>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return</param>
    /// <param name= "argsOut">Array of Object output arguments</param>
    /// <param name= "argsIn">Array of Object input arguments</param>
    /// <param name= "varArgsIn">Array of Object representing variable input
    /// arguments</param>
    ///
    [MATLABSignature("PlotIteration", 5, 0, 1)]
    protected void PlotIteration(int numArgsOut, ref Object[] argsOut, Object[] argsIn, params Object[] varArgsIn)
    {
        mcr.EvaluateFunctionForTypeSafeCall("PlotIteration", numArgsOut, ref argsOut, argsIn, varArgsIn);
    }
    /// <summary>
    /// Provides a void output, 0-input Objectinterface to the PlotLine MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    ///
    public void PlotLine()
    {
      mcr.EvaluateFunction(0, "PlotLine", new Object[]{});
    }


    /// <summary>
    /// Provides a void output, 1-input Objectinterface to the PlotLine MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="posx1">Input argument #1</param>
    ///
    public void PlotLine(Object posx1)
    {
      mcr.EvaluateFunction(0, "PlotLine", posx1);
    }


    /// <summary>
    /// Provides a void output, 2-input Objectinterface to the PlotLine MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="posx1">Input argument #1</param>
    /// <param name="posy1">Input argument #2</param>
    ///
    public void PlotLine(Object posx1, Object posy1)
    {
      mcr.EvaluateFunction(0, "PlotLine", posx1, posy1);
    }


    /// <summary>
    /// Provides a void output, 3-input Objectinterface to the PlotLine MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="posx1">Input argument #1</param>
    /// <param name="posy1">Input argument #2</param>
    /// <param name="posx2">Input argument #3</param>
    ///
    public void PlotLine(Object posx1, Object posy1, Object posx2)
    {
      mcr.EvaluateFunction(0, "PlotLine", posx1, posy1, posx2);
    }


    /// <summary>
    /// Provides a void output, 4-input Objectinterface to the PlotLine MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="posx1">Input argument #1</param>
    /// <param name="posy1">Input argument #2</param>
    /// <param name="posx2">Input argument #3</param>
    /// <param name="posy2">Input argument #4</param>
    ///
    public void PlotLine(Object posx1, Object posy1, Object posx2, Object posy2)
    {
      mcr.EvaluateFunction(0, "PlotLine", posx1, posy1, posx2, posy2);
    }


    /// <summary>
    /// Provides the standard 0-input Object interface to the PlotLine MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotLine(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotLine", new Object[]{});
    }


    /// <summary>
    /// Provides the standard 1-input Object interface to the PlotLine MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="posx1">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotLine(int numArgsOut, Object posx1)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotLine", posx1);
    }


    /// <summary>
    /// Provides the standard 2-input Object interface to the PlotLine MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="posx1">Input argument #1</param>
    /// <param name="posy1">Input argument #2</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotLine(int numArgsOut, Object posx1, Object posy1)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotLine", posx1, posy1);
    }


    /// <summary>
    /// Provides the standard 3-input Object interface to the PlotLine MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="posx1">Input argument #1</param>
    /// <param name="posy1">Input argument #2</param>
    /// <param name="posx2">Input argument #3</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotLine(int numArgsOut, Object posx1, Object posy1, Object posx2)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotLine", posx1, posy1, posx2);
    }


    /// <summary>
    /// Provides the standard 4-input Object interface to the PlotLine MATLAB function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="posx1">Input argument #1</param>
    /// <param name="posy1">Input argument #2</param>
    /// <param name="posx2">Input argument #3</param>
    /// <param name="posy2">Input argument #4</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotLine(int numArgsOut, Object posx1, Object posy1, Object posx2, 
                       Object posy2)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotLine", posx1, posy1, posx2, posy2);
    }


    /// <summary>
    /// Provides an interface for the PlotLine function in which the input and output
    /// arguments are specified as an array of Objects.
    /// </summary>
    /// <remarks>
    /// This method will allocate and return by reference the output argument
    /// array.<newpara></newpara>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return</param>
    /// <param name= "argsOut">Array of Object output arguments</param>
    /// <param name= "argsIn">Array of Object input arguments</param>
    /// <param name= "varArgsIn">Array of Object representing variable input
    /// arguments</param>
    ///
    [MATLABSignature("PlotLine", 4, 0, 0)]
    protected void PlotLine(int numArgsOut, ref Object[] argsOut, Object[] argsIn, params Object[] varArgsIn)
    {
        mcr.EvaluateFunctionForTypeSafeCall("PlotLine", numArgsOut, ref argsOut, argsIn, varArgsIn);
    }
    /// <summary>
    /// Provides a void output, 0-input Objectinterface to the PlotNameCircle MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    ///
    public void PlotNameCircle()
    {
      mcr.EvaluateFunction(0, "PlotNameCircle", new Object[]{});
    }


    /// <summary>
    /// Provides a void output, 1-input Objectinterface to the PlotNameCircle MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="posx">Input argument #1</param>
    ///
    public void PlotNameCircle(Object posx)
    {
      mcr.EvaluateFunction(0, "PlotNameCircle", posx);
    }


    /// <summary>
    /// Provides a void output, 2-input Objectinterface to the PlotNameCircle MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="posx">Input argument #1</param>
    /// <param name="posy">Input argument #2</param>
    ///
    public void PlotNameCircle(Object posx, Object posy)
    {
      mcr.EvaluateFunction(0, "PlotNameCircle", posx, posy);
    }


    /// <summary>
    /// Provides a void output, 3-input Objectinterface to the PlotNameCircle MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="posx">Input argument #1</param>
    /// <param name="posy">Input argument #2</param>
    /// <param name="string0">Input argument #3</param>
    ///
    public void PlotNameCircle(Object posx, Object posy, Object string0)
    {
      mcr.EvaluateFunction(0, "PlotNameCircle", posx, posy, string0);
    }


    /// <summary>
    /// Provides the standard 0-input Object interface to the PlotNameCircle MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotNameCircle(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotNameCircle", new Object[]{});
    }


    /// <summary>
    /// Provides the standard 1-input Object interface to the PlotNameCircle MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="posx">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotNameCircle(int numArgsOut, Object posx)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotNameCircle", posx);
    }


    /// <summary>
    /// Provides the standard 2-input Object interface to the PlotNameCircle MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="posx">Input argument #1</param>
    /// <param name="posy">Input argument #2</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotNameCircle(int numArgsOut, Object posx, Object posy)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotNameCircle", posx, posy);
    }


    /// <summary>
    /// Provides the standard 3-input Object interface to the PlotNameCircle MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="posx">Input argument #1</param>
    /// <param name="posy">Input argument #2</param>
    /// <param name="string0">Input argument #3</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotNameCircle(int numArgsOut, Object posx, Object posy, Object 
                             string0)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotNameCircle", posx, posy, string0);
    }


    /// <summary>
    /// Provides an interface for the PlotNameCircle function in which the input and
    /// output
    /// arguments are specified as an array of Objects.
    /// </summary>
    /// <remarks>
    /// This method will allocate and return by reference the output argument
    /// array.<newpara></newpara>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return</param>
    /// <param name= "argsOut">Array of Object output arguments</param>
    /// <param name= "argsIn">Array of Object input arguments</param>
    /// <param name= "varArgsIn">Array of Object representing variable input
    /// arguments</param>
    ///
    [MATLABSignature("PlotNameCircle", 3, 0, 0)]
    protected void PlotNameCircle(int numArgsOut, ref Object[] argsOut, Object[] argsIn, params Object[] varArgsIn)
    {
        mcr.EvaluateFunctionForTypeSafeCall("PlotNameCircle", numArgsOut, ref argsOut, argsIn, varArgsIn);
    }
    /// <summary>
    /// Provides a void output, 0-input Objectinterface to the PlotTraficLight MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    ///
    public void PlotTraficLight()
    {
      mcr.EvaluateFunction(0, "PlotTraficLight", new Object[]{});
    }


    /// <summary>
    /// Provides a void output, 1-input Objectinterface to the PlotTraficLight MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    ///
    public void PlotTraficLight(Object axeshandle)
    {
      mcr.EvaluateFunction(0, "PlotTraficLight", axeshandle);
    }


    /// <summary>
    /// Provides a void output, 2-input Objectinterface to the PlotTraficLight MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="posx">Input argument #2</param>
    ///
    public void PlotTraficLight(Object axeshandle, Object posx)
    {
      mcr.EvaluateFunction(0, "PlotTraficLight", axeshandle, posx);
    }


    /// <summary>
    /// Provides a void output, 3-input Objectinterface to the PlotTraficLight MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="posx">Input argument #2</param>
    /// <param name="posy">Input argument #3</param>
    ///
    public void PlotTraficLight(Object axeshandle, Object posx, Object posy)
    {
      mcr.EvaluateFunction(0, "PlotTraficLight", axeshandle, posx, posy);
    }


    /// <summary>
    /// Provides a void output, 4-input Objectinterface to the PlotTraficLight MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="posx">Input argument #2</param>
    /// <param name="posy">Input argument #3</param>
    /// <param name="color">Input argument #4</param>
    ///
    public void PlotTraficLight(Object axeshandle, Object posx, Object posy, Object color)
    {
      mcr.EvaluateFunction(0, "PlotTraficLight", axeshandle, posx, posy, color);
    }


    /// <summary>
    /// Provides the standard 0-input Object interface to the PlotTraficLight MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotTraficLight(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotTraficLight", new Object[]{});
    }


    /// <summary>
    /// Provides the standard 1-input Object interface to the PlotTraficLight MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotTraficLight(int numArgsOut, Object axeshandle)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotTraficLight", axeshandle);
    }


    /// <summary>
    /// Provides the standard 2-input Object interface to the PlotTraficLight MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="posx">Input argument #2</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotTraficLight(int numArgsOut, Object axeshandle, Object posx)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotTraficLight", axeshandle, posx);
    }


    /// <summary>
    /// Provides the standard 3-input Object interface to the PlotTraficLight MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="posx">Input argument #2</param>
    /// <param name="posy">Input argument #3</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotTraficLight(int numArgsOut, Object axeshandle, Object posx, 
                              Object posy)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotTraficLight", axeshandle, posx, posy);
    }


    /// <summary>
    /// Provides the standard 4-input Object interface to the PlotTraficLight MATLAB
    /// function.
    /// </summary>
    /// <remarks>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="axeshandle">Input argument #1</param>
    /// <param name="posx">Input argument #2</param>
    /// <param name="posy">Input argument #3</param>
    /// <param name="color">Input argument #4</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public Object[] PlotTraficLight(int numArgsOut, Object axeshandle, Object posx, 
                              Object posy, Object color)
    {
      return mcr.EvaluateFunction(numArgsOut, "PlotTraficLight", axeshandle, posx, posy, color);
    }


    /// <summary>
    /// Provides an interface for the PlotTraficLight function in which the input and
    /// output
    /// arguments are specified as an array of Objects.
    /// </summary>
    /// <remarks>
    /// This method will allocate and return by reference the output argument
    /// array.<newpara></newpara>
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return</param>
    /// <param name= "argsOut">Array of Object output arguments</param>
    /// <param name= "argsIn">Array of Object input arguments</param>
    /// <param name= "varArgsIn">Array of Object representing variable input
    /// arguments</param>
    ///
    [MATLABSignature("PlotTraficLight", 4, 0, 0)]
    protected void PlotTraficLight(int numArgsOut, ref Object[] argsOut, Object[] argsIn, params Object[] varArgsIn)
    {
        mcr.EvaluateFunctionForTypeSafeCall("PlotTraficLight", numArgsOut, ref argsOut, argsIn, varArgsIn);
    }

    /// <summary>
    /// This method will cause a MATLAB figure window to behave as a modal dialog box.
    /// The method will not return until all the figure windows associated with this
    /// component have been closed.
    /// </summary>
    /// <remarks>
    /// An application should only call this method when required to keep the
    /// MATLAB figure window from disappearing.  Other techniques, such as calling
    /// Console.ReadLine() from the application should be considered where
    /// possible.</remarks>
    ///
    public void WaitForFiguresToDie()
    {
      mcr.WaitForFiguresToDie();
    }



    #endregion Methods

    #region Class Members

    private static MWMCR mcr= null;

    private static Exception ex_= null;

    private bool disposed= false;

    #endregion Class Members
  }
}
